home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / share / gtk-2.0 / demo / appwindow.c < prev    next >
Encoding:
C/C++ Source or Header  |  2006-04-25  |  18.7 KB  |  594 lines

  1. /* Application main window
  2.  *
  3.  * Demonstrates a typical application window with menubar, toolbar, statusbar.
  4.  */
  5.  
  6. #include <gtk/gtk.h>
  7. #include "config.h"
  8. #include "demo-common.h"
  9.  
  10. static GtkWidget *window = NULL;
  11.  
  12. static void
  13. activate_action (GtkAction *action)
  14. {
  15.   const gchar *name = gtk_action_get_name (action);
  16.   const gchar *typename = G_OBJECT_TYPE_NAME (action);
  17.  
  18.   GtkWidget *dialog;
  19.   
  20.   dialog = gtk_message_dialog_new (GTK_WINDOW (window),
  21.                                    GTK_DIALOG_DESTROY_WITH_PARENT,
  22.                                    GTK_MESSAGE_INFO,
  23.                                    GTK_BUTTONS_CLOSE,
  24.                                    "You activated action: \"%s\" of type \"%s\"",
  25.                                     name, typename);
  26.  
  27.   /* Close dialog on user response */
  28.   g_signal_connect (dialog,
  29.                     "response",
  30.                     G_CALLBACK (gtk_widget_destroy),
  31.                     NULL);
  32.   
  33.   gtk_widget_show (dialog);
  34. }
  35.  
  36. static void
  37. activate_radio_action (GtkAction *action, GtkRadioAction *current)
  38. {
  39.   const gchar *name = gtk_action_get_name (GTK_ACTION (current));
  40.   const gchar *typename = G_OBJECT_TYPE_NAME (GTK_ACTION (current));
  41.   gboolean active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (current));
  42.   gint value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (current));
  43.  
  44.   if (active) 
  45.     {
  46.       GtkWidget *dialog;
  47.   
  48.       dialog = gtk_message_dialog_new (GTK_WINDOW (window),
  49.                        GTK_DIALOG_DESTROY_WITH_PARENT,
  50.                        GTK_MESSAGE_INFO,
  51.                        GTK_BUTTONS_CLOSE,
  52.                        "You activated radio action: \"%s\" of type \"%s\".\n"
  53.                        "Current value: %d",
  54.                        name, typename, value);
  55.  
  56.       /* Close dialog on user response */
  57.       g_signal_connect (dialog,
  58.             "response",
  59.             G_CALLBACK (gtk_widget_destroy),
  60.             NULL);
  61.       
  62.       gtk_widget_show (dialog);
  63.     }
  64. }
  65.  
  66. static void 
  67. activate_email (GtkAboutDialog *about,
  68.         const gchar    *link,
  69.         gpointer        data)
  70. {
  71.   g_print ("send mail to %s\n", link);
  72. }
  73.  
  74. static void 
  75. activate_url (GtkAboutDialog *about,
  76.           const gchar    *link,
  77.           gpointer        data)
  78. {
  79.   g_print ("show url %s\n", link);
  80. }
  81.  
  82. static void
  83. about_cb (GtkAction *action,
  84.       GtkWidget *window)
  85. {
  86.   GdkPixbuf *pixbuf, *transparent;
  87.   gchar *filename;
  88.  
  89.   const gchar *authors[] = {
  90.     "Peter Mattis",
  91.     "Spencer Kimball",
  92.     "Josh MacDonald",
  93.     "and many more...",
  94.     NULL
  95.   };
  96.  
  97.   const gchar *documentors[] = {
  98.     "Owen Taylor",
  99.     "Tony Gale",
  100.     "Matthias Clasen <mclasen@redhat.com>",
  101.     "and many more...",
  102.     NULL
  103.   };
  104.  
  105.   const gchar *license =
  106.     "This library is free software; you can redistribute it and/or\n"
  107.     "modify it under the terms of the GNU Library General Public License as\n"
  108.     "published by the Free Software Foundation; either version 2 of the\n"
  109.     "License, or (at your option) any later version.\n"
  110.     "\n"
  111.     "This library is distributed in the hope that it will be useful,\n"
  112.     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
  113.     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
  114.     "Library General Public License for more details.\n"
  115.     "\n"
  116.     "You should have received a copy of the GNU Library General Public\n"
  117.     "License along with the Gnome Library; see the file COPYING.LIB.  If not,\n"
  118.     "write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,\n"
  119.     "Boston, MA 02111-1307, USA.\n";
  120.  
  121.   pixbuf = NULL;
  122.   transparent = NULL;
  123.   filename = demo_find_file ("gtk-logo-rgb.gif", NULL);
  124.   if (filename)
  125.     {
  126.       pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
  127.       g_free (filename);
  128.       transparent = gdk_pixbuf_add_alpha (pixbuf, TRUE, 0xff, 0xff, 0xff);
  129.       g_object_unref (pixbuf);
  130.     }
  131.  
  132.   gtk_about_dialog_set_email_hook (activate_email, NULL, NULL);
  133.   gtk_about_dialog_set_url_hook (activate_url, NULL, NULL);
  134.   gtk_show_about_dialog (GTK_WINDOW (window),
  135.              "name", "GTK+ Code Demos",
  136.              "version", PACKAGE_VERSION,
  137.              "copyright", "(C) 1997-2005 The GTK+ Team",
  138.              "license", license,
  139.              "website", "http://www.gtk.org",
  140.              "comments", "Program to demonstrate GTK+ functions.",
  141.              "authors", authors,
  142.              "documenters", documentors,
  143.              "logo", transparent,
  144.              NULL);
  145.  
  146.   g_object_unref (transparent);
  147. }
  148.  
  149. typedef struct 
  150. {
  151.   GtkAction action;
  152. } ToolMenuAction;
  153.  
  154. typedef struct 
  155. {
  156.   GtkActionClass parent_class;
  157. } ToolMenuActionClass;
  158.  
  159. G_DEFINE_TYPE(ToolMenuAction, tool_menu_action, GTK_TYPE_ACTION);
  160.  
  161. static void
  162. tool_menu_action_class_init (ToolMenuActionClass *class)
  163. {
  164.   GTK_ACTION_CLASS (class)->toolbar_item_type = GTK_TYPE_MENU_TOOL_BUTTON;
  165. }
  166.  
  167. static void
  168. tool_menu_action_init (ToolMenuAction *action)
  169. {
  170. }
  171.  
  172. static GtkActionEntry entries[] = {
  173.   { "FileMenu", NULL, "_File" },               /* name, stock id, label */
  174.   { "OpenMenu", NULL, "_Open" },               /* name, stock id, label */
  175.   { "PreferencesMenu", NULL, "_Preferences" }, /* name, stock id, label */
  176.   { "ColorMenu", NULL, "_Color"  },            /* name, stock id, label */
  177.   { "ShapeMenu", NULL, "_Shape" },             /* name, stock id, label */
  178.   { "HelpMenu", NULL, "_Help" },               /* name, stock id, label */
  179.   { "New", GTK_STOCK_NEW,                      /* name, stock id */
  180.     "_New", "<control>N",                      /* label, accelerator */
  181.     "Create a new file",                       /* tooltip */ 
  182.     G_CALLBACK (activate_action) },      
  183.   { "File1", NULL,                             /* name, stock id */
  184.     "File1", NULL,                             /* label, accelerator */     
  185.     "Open first file",                         /* tooltip */
  186.     G_CALLBACK (activate_action) }, 
  187.   { "Save", GTK_STOCK_SAVE,                    /* name, stock id */
  188.     "_Save","<control>S",                      /* label, accelerator */     
  189.     "Save current file",                       /* tooltip */
  190.     G_CALLBACK (activate_action) },
  191.   { "SaveAs", GTK_STOCK_SAVE,                  /* name, stock id */
  192.     "Save _As...", NULL,                       /* label, accelerator */     
  193.     "Save to a file",                          /* tooltip */
  194.     G_CALLBACK (activate_action) },
  195.   { "Quit", GTK_STOCK_QUIT,                    /* name, stock id */
  196.     "_Quit", "<control>Q",                     /* label, accelerator */     
  197.     "Quit",                                    /* tooltip */
  198.     G_CALLBACK (activate_action) },
  199.   { "About", NULL,                             /* name, stock id */
  200.     "_About", "<control>A",                    /* label, accelerator */     
  201.     "About",                                   /* tooltip */  
  202.     G_CALLBACK (about_cb) },
  203.   { "Logo", "demo-gtk-logo",                   /* name, stock id */
  204.      NULL, NULL,                               /* label, accelerator */     
  205.     "GTK+",                                    /* tooltip */
  206.     G_CALLBACK (activate_action) },
  207. };
  208. static guint n_entries = G_N_ELEMENTS (entries);
  209.  
  210.  
  211. static GtkToggleActionEntry toggle_entries[] = {
  212.   { "Bold", GTK_STOCK_BOLD,                    /* name, stock id */
  213.      "_Bold", "<control>B",                    /* label, accelerator */     
  214.     "Bold",                                    /* tooltip */
  215.     G_CALLBACK (activate_action), 
  216.     TRUE },                                    /* is_active */
  217. };
  218. static guint n_toggle_entries = G_N_ELEMENTS (toggle_entries);
  219.  
  220. enum {
  221.   COLOR_RED,
  222.   COLOR_GREEN,
  223.   COLOR_BLUE
  224. };
  225.  
  226. static GtkRadioActionEntry color_entries[] = {
  227.   { "Red", NULL,                               /* name, stock id */
  228.     "_Red", "<control>R",                      /* label, accelerator */     
  229.     "Blood", COLOR_RED },                      /* tooltip, value */
  230.   { "Green", NULL,                             /* name, stock id */
  231.     "_Green", "<control>G",                    /* label, accelerator */     
  232.     "Grass", COLOR_GREEN },                    /* tooltip, value */
  233.   { "Blue", NULL,                              /* name, stock id */
  234.     "_Blue", "<control>B",                     /* label, accelerator */     
  235.     "Sky", COLOR_BLUE },                       /* tooltip, value */
  236. };
  237. static guint n_color_entries = G_N_ELEMENTS (color_entries);
  238.  
  239. enum {
  240.   SHAPE_SQUARE,
  241.   SHAPE_RECTANGLE,
  242.   SHAPE_OVAL
  243. };
  244.  
  245. static GtkRadioActionEntry shape_entries[] = {
  246.   { "Square", NULL,                            /* name, stock id */
  247.     "_Square", "<control>S",                   /* label, accelerator */     
  248.     "Square",  SHAPE_SQUARE },                 /* tooltip, value */
  249.   { "Rectangle", NULL,                         /* name, stock id */
  250.     "_Rectangle", "<control>R",                /* label, accelerator */     
  251.     "Rectangle", SHAPE_RECTANGLE },            /* tooltip, value */
  252.   { "Oval", NULL,                              /* name, stock id */
  253.     "_Oval", "<control>O",                     /* label, accelerator */     
  254.     "Egg", SHAPE_OVAL },                       /* tooltip, value */  
  255. };
  256. static guint n_shape_entries = G_N_ELEMENTS (shape_entries);
  257.  
  258. static const gchar *ui_info = 
  259. "<ui>"
  260. "  <menubar name='MenuBar'>"
  261. "    <menu action='FileMenu'>"
  262. "      <menuitem action='New'/>"
  263. "      <menuitem action='Open'/>"
  264. "      <menuitem action='Save'/>"
  265. "      <menuitem action='SaveAs'/>"
  266. "      <separator/>"
  267. "      <menuitem action='Quit'/>"
  268. "    </menu>"
  269. "    <menu action='PreferencesMenu'>"
  270. "      <menu action='ColorMenu'>"
  271. "    <menuitem action='Red'/>"
  272. "    <menuitem action='Green'/>"
  273. "    <menuitem action='Blue'/>"
  274. "      </menu>"
  275. "      <menu action='ShapeMenu'>"
  276. "        <menuitem action='Square'/>"
  277. "        <menuitem action='Rectangle'/>"
  278. "        <menuitem action='Oval'/>"
  279. "      </menu>"
  280. "      <menuitem action='Bold'/>"
  281. "    </menu>"
  282. "    <menu action='HelpMenu'>"
  283. "      <menuitem action='About'/>"
  284. "    </menu>"
  285. "  </menubar>"
  286. "  <toolbar name='ToolBar'>"
  287. "    <toolitem action='Open'>"
  288. "      <menu action='OpenMenu'>"
  289. "        <menuitem action='File1'/>"
  290. "      </menu>"  
  291. "    </toolitem>"
  292. "    <toolitem action='Quit'/>"
  293. "    <separator action='Sep1'/>"
  294. "    <toolitem action='Logo'/>"
  295. "  </toolbar>"
  296. "</ui>";
  297.  
  298.  
  299.  
  300. /* This function registers our custom toolbar icons, so they can be themed.
  301.  *
  302.  * It's totally optional to do this, you could just manually insert icons
  303.  * and have them not be themeable, especially if you never expect people
  304.  * to theme your app.
  305.  */
  306. static void
  307. register_stock_icons (void)
  308. {
  309.   static gboolean registered = FALSE;
  310.   
  311.   if (!registered)
  312.     {
  313.       GdkPixbuf *pixbuf;
  314.       GtkIconFactory *factory;
  315.       char *filename;
  316.  
  317.       static GtkStockItem items[] = {
  318.         { "demo-gtk-logo",
  319.           "_GTK!",
  320.           0, 0, NULL }
  321.       };
  322.       
  323.       registered = TRUE;
  324.  
  325.       /* Register our stock items */
  326.       gtk_stock_add (items, G_N_ELEMENTS (items));
  327.       
  328.       /* Add our custom icon factory to the list of defaults */
  329.       factory = gtk_icon_factory_new ();
  330.       gtk_icon_factory_add_default (factory);
  331.  
  332.       /* demo_find_file() looks in the the current directory first,
  333.        * so you can run gtk-demo without installing GTK, then looks
  334.        * in the location where the file is installed.
  335.        */
  336.       pixbuf = NULL;
  337.       filename = demo_find_file ("gtk-logo-rgb.gif", NULL);
  338.       if (filename)
  339.     {
  340.       pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
  341.       g_free (filename);
  342.     }
  343.  
  344.       /* Register icon to accompany stock item */
  345.       if (pixbuf != NULL)
  346.         {
  347.           GtkIconSet *icon_set;
  348.           GdkPixbuf *transparent;
  349.  
  350.           /* The gtk-logo-rgb icon has a white background, make it transparent */
  351.           transparent = gdk_pixbuf_add_alpha (pixbuf, TRUE, 0xff, 0xff, 0xff);
  352.           
  353.           icon_set = gtk_icon_set_new_from_pixbuf (transparent);
  354.           gtk_icon_factory_add (factory, "demo-gtk-logo", icon_set);
  355.           gtk_icon_set_unref (icon_set);
  356.           g_object_unref (pixbuf);
  357.           g_object_unref (transparent);
  358.         }
  359.       else
  360.         g_warning ("failed to load GTK logo for toolbar");
  361.       
  362.       /* Drop our reference to the factory, GTK will hold a reference. */
  363.       g_object_unref (factory);
  364.     }
  365. }
  366.  
  367. static void
  368. update_statusbar (GtkTextBuffer *buffer,
  369.                   GtkStatusbar  *statusbar)
  370. {
  371.   gchar *msg;
  372.   gint row, col;
  373.   gint count;
  374.   GtkTextIter iter;
  375.   
  376.   gtk_statusbar_pop (statusbar, 0); /* clear any previous message, 
  377.                      * underflow is allowed 
  378.                      */
  379.  
  380.   count = gtk_text_buffer_get_char_count (buffer);
  381.  
  382.   gtk_text_buffer_get_iter_at_mark (buffer,
  383.                                     &iter,
  384.                                     gtk_text_buffer_get_insert (buffer));
  385.  
  386.   row = gtk_text_iter_get_line (&iter);
  387.   col = gtk_text_iter_get_line_offset (&iter);
  388.  
  389.   msg = g_strdup_printf ("Cursor at row %d column %d - %d chars in document",
  390.                          row, col, count);
  391.  
  392.   gtk_statusbar_push (statusbar, 0, msg);
  393.  
  394.   g_free (msg);
  395. }
  396.  
  397. static void
  398. mark_set_callback (GtkTextBuffer     *buffer,
  399.                    const GtkTextIter *new_location,
  400.                    GtkTextMark       *mark,
  401.                    gpointer           data)
  402. {
  403.   update_statusbar (buffer, GTK_STATUSBAR (data));
  404. }
  405.  
  406. static void
  407. update_resize_grip (GtkWidget           *widget,
  408.             GdkEventWindowState *event,
  409.             GtkStatusbar        *statusbar)
  410. {
  411.   if (event->changed_mask & (GDK_WINDOW_STATE_MAXIMIZED | 
  412.                  GDK_WINDOW_STATE_FULLSCREEN))
  413.     {
  414.       gboolean maximized;
  415.  
  416.       maximized = event->new_window_state & (GDK_WINDOW_STATE_MAXIMIZED | 
  417.                          GDK_WINDOW_STATE_FULLSCREEN);
  418.       gtk_statusbar_set_has_resize_grip (statusbar, !maximized);
  419.     }
  420. }
  421.             
  422.  
  423. GtkWidget *
  424. do_appwindow (GtkWidget *do_widget)
  425. {  
  426.   if (!window)
  427.     {
  428.       GtkWidget *table;
  429.       GtkWidget *statusbar;
  430.       GtkWidget *contents;
  431.       GtkWidget *sw;
  432.       GtkWidget *bar;
  433.       GtkTextBuffer *buffer;
  434.       GtkActionGroup *action_group;
  435.       GtkAction *open_action;
  436.       GtkUIManager *merge;
  437.       GError *error = NULL;
  438.  
  439.       register_stock_icons ();
  440.       
  441.       /* Create the toplevel window
  442.        */
  443.       
  444.       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  445.       gtk_window_set_screen (GTK_WINDOW (window),
  446.                  gtk_widget_get_screen (do_widget));
  447.       gtk_window_set_title (GTK_WINDOW (window), "Application Window");
  448.       gtk_window_set_icon_name (GTK_WINDOW (window), "gtk-open");
  449.  
  450.       /* NULL window variable when window is closed */
  451.       g_signal_connect (window, "destroy",
  452.                         G_CALLBACK (gtk_widget_destroyed),
  453.                         &window);
  454.  
  455.       table = gtk_table_new (1, 4, FALSE);
  456.       
  457.       gtk_container_add (GTK_CONTAINER (window), table);
  458.       
  459.       /* Create the menubar and toolbar
  460.        */
  461.       
  462.       action_group = gtk_action_group_new ("AppWindowActions");
  463.       open_action = g_object_new (tool_menu_action_get_type (), 
  464.                   "name", "Open",
  465.                   "label", "_Open",
  466.                   "tooltip", "Open a file",
  467.                   "stock-id", GTK_STOCK_OPEN,
  468.                   NULL);
  469.       gtk_action_group_add_action (action_group, open_action);
  470.       gtk_action_group_add_actions (action_group, 
  471.                     entries, n_entries, 
  472.                     window);
  473.       gtk_action_group_add_toggle_actions (action_group, 
  474.                        toggle_entries, n_toggle_entries, 
  475.                        NULL);
  476.       gtk_action_group_add_radio_actions (action_group, 
  477.                       color_entries, n_color_entries, 
  478.                       COLOR_RED,
  479.                       G_CALLBACK (activate_radio_action), 
  480.                       NULL);
  481.       gtk_action_group_add_radio_actions (action_group, 
  482.                       shape_entries, n_shape_entries, 
  483.                       SHAPE_SQUARE,
  484.                       G_CALLBACK (activate_radio_action), 
  485.                       NULL);
  486.  
  487.       merge = gtk_ui_manager_new ();
  488.       g_object_set_data_full (G_OBJECT (window), "ui-manager", merge, 
  489.                   g_object_unref);
  490.       gtk_ui_manager_insert_action_group (merge, action_group, 0);
  491.       gtk_window_add_accel_group (GTK_WINDOW (window), 
  492.                   gtk_ui_manager_get_accel_group (merge));
  493.       
  494.       if (!gtk_ui_manager_add_ui_from_string (merge, ui_info, -1, &error))
  495.     {
  496.       g_message ("building menus failed: %s", error->message);
  497.       g_error_free (error);
  498.     }
  499.  
  500.       bar = gtk_ui_manager_get_widget (merge, "/MenuBar");
  501.       gtk_widget_show (bar);
  502.       gtk_table_attach (GTK_TABLE (table),
  503.             bar, 
  504.                         /* X direction */          /* Y direction */
  505.                         0, 1,                      0, 1,
  506.                         GTK_EXPAND | GTK_FILL,     0,
  507.                         0,                         0);
  508.  
  509.       bar = gtk_ui_manager_get_widget (merge, "/ToolBar");
  510.       gtk_toolbar_set_tooltips (GTK_TOOLBAR (bar), TRUE);
  511.       gtk_widget_show (bar);
  512.       gtk_table_attach (GTK_TABLE (table),
  513.             bar, 
  514.                         /* X direction */       /* Y direction */
  515.                         0, 1,                   1, 2,
  516.                         GTK_EXPAND | GTK_FILL,  0,
  517.                         0,                      0);
  518.  
  519.       /* Create document
  520.        */
  521.  
  522.       sw = gtk_scrolled_window_new (NULL, NULL);
  523.  
  524.       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
  525.                                       GTK_POLICY_AUTOMATIC,
  526.                                       GTK_POLICY_AUTOMATIC);
  527.  
  528.       gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
  529.                                            GTK_SHADOW_IN);
  530.       
  531.       gtk_table_attach (GTK_TABLE (table),
  532.                         sw,
  533.                         /* X direction */       /* Y direction */
  534.                         0, 1,                   2, 3,
  535.                         GTK_EXPAND | GTK_FILL,  GTK_EXPAND | GTK_FILL,
  536.                         0,                      0);
  537.  
  538.       gtk_window_set_default_size (GTK_WINDOW (window),
  539.                                    200, 200);
  540.       
  541.       contents = gtk_text_view_new ();
  542.       gtk_widget_grab_focus (contents);
  543.       
  544.       gtk_container_add (GTK_CONTAINER (sw),
  545.                          contents);
  546.  
  547.       /* Create statusbar */
  548.  
  549.       statusbar = gtk_statusbar_new ();
  550.       gtk_table_attach (GTK_TABLE (table),
  551.                         statusbar,
  552.                         /* X direction */       /* Y direction */
  553.                         0, 1,                   3, 4,
  554.                         GTK_EXPAND | GTK_FILL,  0,
  555.                         0,                      0);
  556.  
  557.       /* Show text widget info in the statusbar */
  558.       buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents));
  559.       
  560.       g_signal_connect_object (buffer,
  561.                                "changed",
  562.                                G_CALLBACK (update_statusbar),
  563.                                statusbar,
  564.                                0);
  565.  
  566.       g_signal_connect_object (buffer,
  567.                                "mark_set", /* cursor moved */
  568.                                G_CALLBACK (mark_set_callback),
  569.                                statusbar,
  570.                                0);
  571.  
  572.       g_signal_connect_object (window, 
  573.                    "window_state_event", 
  574.                    G_CALLBACK (update_resize_grip),
  575.                    statusbar,
  576.                    0);
  577.       
  578.       update_statusbar (buffer, GTK_STATUSBAR (statusbar));
  579.     }
  580.  
  581.   if (!GTK_WIDGET_VISIBLE (window))
  582.     {
  583.       gtk_widget_show_all (window);
  584.     }
  585.   else
  586.     {    
  587.       gtk_widget_destroy (window);
  588.       window = NULL;
  589.     }
  590.  
  591.   return window;
  592. }
  593.  
  594.